Deutsche Edition 1/Deutsche Edition 1.iso/amok/031-040/amok31/environment/mpcompile.dok

Text File | 1993-11-04 | 10KB | 230 lines

Dokumentation zu

                MPCompile   V3.0

                            von Markus Peuckert


COPYRIGHT:            M.Peuckert
                Steinweg 18
                3501 Ahnatal-Weimar

            Copyright (c) 1989 by M.Peuckert

  Sämtliche Urheberrechte liegen beim Autor. Dieses Programm darf frei
kopiert werden, es ist Public-Domain.
Es wird jegliche Art von Garantien abgelehnt, welche die Tauglichkeit der
Software für einen bestimmten Zweck versprechen. Für Fehler in der
Dokumentation und im Programm werden nicht gehaftet. Auch nicht für Schäden,
die durch den Gebrauch der Dokumentation, deren Inhalt oder von der Software
direkt oder indirekt entstehen.


BEILAGEN:
        - Das Programm MPCompile V3.0
        - Diese Dokumentation


VORWEG:
  Dieses Utility ist als Programmierhilfe für beliebige Programmierumgebungen
gedacht. Besonders für Modula-2 Programmierer ist es interessant, da es in
dieser Sprache geschrieben ist (M2Amiga A+L AG). Benutzer anderer
Compiler werden aber auch eine nützliche Hilfe darin sehen, weil durch die
Verwendung von Platzhaltern, für das zu compilierende/linkende Programm, eine
hohe Flexibilität geboten wird.

AUFRUF:
  Rufen Sie MPCompile über das CLI auf, da es beim Aufruf über die Workbench
sonst zu einem "Stack Overflow" des von MPCompile aufgerufenen Compilers/Linkers
führen kann. Am besten Sie starten mit "Run MPCompile" und sehen was sich tut:

INITIALISIEREN:
  Es öffnen sich drei Fenster. Das Oberste ist das Steuerfenster über die alle
Aufrufe geschehen. Darunter wird ein CONSOLE-Fenster geöffnet für die Ausgaben
des Compilers/Linkers/Debuggers etc. Danach wird das sogenannte
"PopWindow Preferences"-Fenster geöffnet in dem in verschiedenen Gadgets die
Aufrufe für Compiler, Linker, Loader/Debugger, den verwendeten Editor und das
von Ihnen zu bearbeitende Programm spezifiziert werden. Sind diese Gadgets
leer, so tragen Sie dort die Art und Weise des Compilers ein, wie er gestartet
wird. Analog müssen Sie in die anderen Gadgets die Aufrufbedingungen der von
Ihnen verwendeten Programme eingetragen werden. Verwenden Sie irgendein Feld
nicht (z.B. keinen Debugger oder Loader), so lassen Sie dieses Feld einfach
frei. In das Feld "Program" tragen Sie einfach ihr zu bearbeitendes SourceCode-
Programm ein (mit vollem Pfadnamen und Suffix z.B. : "vd0:MPCompile.Mod").

  Nun muß noch einiges zum Platzhalter gesagt werden. Damit MPCompile weiß, wo
der Programmname ihres Programmes im, z.B., Compileraufruf eingefügt werden
muß, geben Sie im Gadget für die Maske des Compileraufrufs ein Doppelkreuz
ein:
        Beispiel:     M2:m2c -Opts #

MPCompile setzt nun ihr Programm, z.B. "Bsp.Mod", beim Aufruf an die Stelle des
Doppelkreuzes:
        M2:m2c -Opts Bsp.Mod

Achten Sie bei der Eingabe in das Feld "Program" (zu compilierendes Programm)
auf Groß/klein-Schreibung. Manche Compiler und/oder Linker und/oder
Loader/Debugger sind da ziemlich pingelig.

Sie können auch die Extension direkt nach dem Doppelkreuz angeben:

Compiler:        M2:m2c -Opts #.Mod    oder
Linker:         M2:m2l #.obj

Nun müssen aber in dem "Program"-Gadget die Extension weglassen, damit kein
falscher Aufruf erfolgt.

Eingabe in das "Program"-Gadget :     vd0:Bsp

Jetzt wird die Extension automatisch angehängt, was
auch für den Linkeraufruf (oder den Loader/Debuggeraufruf) wichtig sein kann,
wenn ganz bestimmte Extensionen gefordert werden.

Analog funktioniert das für den Linker-,Loader-,Debugger-,Editoraufruf.

Bei manchen Compilern kann man die Optionen erst NACH Angabe des zu
compilierenden Programmes angeben. Dafür ist die Verwendung des Platzhalters
gedacht. Source : "Bsp.c".

    Beispiel:    cc # -Opts        wird zusammengesetzt zu

            cc Bsp.c -Opts

Viele Linker laufen z.T. nur so:
            ln # -Opts    ==>  ln Bsp -Opts        oder
            ln #.o -Opts  ==>  ln Bsp.o -Opts.


PFADNAME:
  Der Pfadname am Anfang des Programmnamens wird von MPCompile extrahiert und
dorthin das aktuelle Directory gesetzt. Damit wird erreicht, daß der aufgerufene
Compiler das compilierte Programm auch dort ablegt und nicht in seinem eigenen
Directory.

EXTENSION:
  Die Extension kann mit angegeben werden. Sie wird automatisch extrahiert für
die Aufrufe des Linkers oder Debuggers, die ja eine andere Extension erwarten
(meistens .o oder .obj).

  Haben Sie alle erforderlichen Eingaben getätigt, können Sie diese mit
Anklicken des "SAVE"-Gadgets abspeichern. Dies geschieht in die Datei
"Compi.config", die eigens dafür im "s:"-Directory der Systemdiskette angelegt
wird.
  Beim Starten von MPCompile wird nachgeschaut, ob diese Datei vorhanden ist und
die gespeicherten Daten eingelesen. Wenn nicht, wird sie automatisch
eingerichtet und Sie können nach Eingabe in die Gadgets des "PopWindow"
abspeichern. Haben Sie die Einstellungen geändert und wollen aber lieber die
Gespeicherten wiederhaben, so klicken Sie einfach das "LOAD"-Gadget an. Die
vorher gespeicherten Einstellungen werden wieder geladen.
Sind diese Initialisierungen erfolgt, klicken Sie das Closing-Gadget an.
Das "PopWindow" wird geschlossen und ...

ARBEITEN:
...  Sie befinden sich im Steuermodus.
Der Name des zu bearbeitenden Programmes wird dabei mit Pfad im Output-Fenster
angezeigt.
  Folgende Gadgets bewirken folgendes:

Compile     : compiliert das eingestellte Programm.
Link        : linkt       "      "          "     .
Load/Debug      : lädt den Loader/Debugger mit dem eingestellten Programm.
Run        : führt die Anweisungen : Compile, Link, Execute nacheinander
          aus. (Nur klicken, wenn Source fehlerfrei ist, sonst
          Linker- und Programmaufruf umsomst)
Execute        : startet das fertig compilierte und gelinkte Programm.
Edit        : startet den eingestellten Editor mit dem eingestellten
          Programm (mit Extension).
Pop        : öffnet das PopWindow und alle Einstellungen können geändert
          werden.

  Klicken Sie nun die gewünschten Operationen an, die dann unverzüglich
ausgeführt werden. Die Ausgaben des Compilers/Linkers/Loaders werden dabei in
das Output-Fenster umgeleitet. Während eine Operation ausgeführt wird, sind
zwar die Gadgets anklickbar, aber der IDCMP ist für dieses Fenster
abgeschaltet. D.h., wenn Sie, während ein Programm läuft, versonnen auf den
Gadgets herumklicken, passiert nichts (Sonst würden, je nachdem welche Gadgets
Sie angeklickt haben, diese Programme nacheinander gestartet, was dann
ewig dauert bis Sie wieder sinnvoll arbeiten können).
Sie können aber auch den CLI-Befehl "Run" vor den Aufruf des gewünschten
Programmes setzen. Es wird damit ein neuer Task gestartet und Sie können mit
MPCompile gleich weiterarbeiten und müssen nicht erst warten bis das aufgerufene
Programm abgearbeitet ist. Am Beispiel des Editors, den man ja nicht immer
zum compilieren verlassen will:

        Run M2:m2emacs #


BESONDERHEITEN:
  Sie können MPCompile iconifizieren indem Sie das Steuerfenster mit dem linken
Mausknopf aktivieren und dann den rechten Mausknopf drücken. Daraufhin wird das
Output-Fenster geschlossen, das Steuerfenster auf ein Minimum verkleinert und
an den rechten Workbenchrand verschoben. Arbeiten Sie dann was Sie wollen.
Wenn Sie wieder mit MPCompile arbeiten wollen, müssen es wieder aktiv-klicken
und dann die rechte Maustaste drücken. Das Steuerfenster und das Output-Fenster
werden dann an die ursprüngliche Stelle gerückt und wieder vergrößert, bzw.
geöffnet. Alle Fenster von MPCompile sind beliebig verschiebbar gehalten
(auch das iconifizierte Steuerfenster).

  Auch eine Umleitung der Ein- und Ausgaben für den Compiler wie unter
[AmigaDOS] ist möglich. Geben Sie hier im "PopWindow" unter Compileraufruf
einfach einen Pfeil und einen Dateinamen für die Umleitung ein.
Zum Beispiel:
    Umleitung der Compilerausgaben in eine Datei "temp" in der RAMDisk:

    M2:m2c >ram:temp #


  Es ist möglich eine Datei als Eingabe für den Compiler zu benutzen, um mehrere
Programme in einem Aufruf zu compilieren (wenn das der Compiler zuläßt).
Beispiel:
    Umleitung der Compilereingabe aus der Datei "Sources" in der RAMDisk:

    M2:m2c <#

  Wobei nun im Popwindow unter "Program" die Datei "ram:Sources" eingetragen
werden muß, damit sich der Compiler dort seine SourcecodeProgramme holen
kann, die er dann nach und nach abarbeitet und das Compilat (WICHTIG!!)
in der RAMDisk abspeichert. Die Datei enthält dann nur die zu compilierenden
Programme, z.B.:

vd0:Source1.Def
vd0:Source1.Mod
vd0:Source2.Mod
vd0:Source3.Def

In diesem Beispiel holt sich der Compiler seine Sourcecodes aus der restfesten
Ramdisk "vd0:" und legt dann die compilierten Objektdateien in der RAMDisk ab.


SPEZIELLES: für Modula-Programmierer:
  Geben Sie für Programm-Module in einer solchen Datei keine Extension an,
und leiten die Eingaben von dieser Datei um, dann kann man compilieren und
linken in einem Durchgang:

    Compiler:    M2:m2c <#
    Linker  :    M2:m2l <#
    Program :    ram:Sources    Datei in der die zu compilierenden
                    Sources definiert sind.
    Editor    :    M2:m2emacs #


So könnte dann "ram:Sources" aussehen:

vd0:Source1.Def            Defintions-Modul    soll nur compiliert werden.
vd0:Source1.Mod            Implentations-Modul  "    "      "        "   .
vd0:Source2.Def            Defintions-Modul    soll nur compiliert werden.
vd0:Source2.Mod            Implentations-Modul  "    "      "        "   .
vd0:MainSource            Programm-Modul soll compiliert und gelinkt
                werden.    (Extension wird weggelassen)

Vom M2-Linker werden nämlich nur solche Dateien anerkannt, die eine Endung mit
".obj" oder keine Endung haben. Der Compiler erkennt Definitions-Module nur
an der Endung ".Def".


Gibt es irdendwelche Bugs (mir sind keine aufgefallen) oder neue Anregungen,
so bitte ich Sie mir doch zu schreiben.

    Viel Spaß noch !
                 Markus